{
 "nbformat": 4,
 "nbformat_minor": 0,
 "metadata": {
  "colab": {
   "name": "PI_DeepONet_Burger.ipynb",
   "provenance": [],
   "collapsed_sections": []
  },
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3"
  },
  "accelerator": "GPU"
 },
 "cells": [
  {
   "cell_type": "code",
   "metadata": {
    "id": "mRR_BT5vUnSw"
   },
   "source": [
    "import numpy as onp\n",
    "import scipy.io\n",
    "from scipy.interpolate import griddata\n",
    "import jax.numpy as np\n",
    "from jax import random, grad, vmap, jit\n",
    "from jax.example_libraries import optimizers\n",
    "from jax.config import config\n",
    "from jax.flatten_util import ravel_pytree\n",
    "from jax.nn import relu, elu\n",
    "import itertools\n",
    "from functools import partial\n",
    "from torch.utils import data\n",
    "from tqdm import trange\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "%matplotlib inline"
   ],
   "execution_count": 10,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "rTZSJ2taqCPZ"
   },
   "source": [
    "# Define MLP\n",
    "def MLP(layers, activation=relu):\n",
    "  ''' Vanilla MLP'''\n",
    "  def init(rng_key):\n",
    "      def init_layer(key, d_in, d_out):\n",
    "          k1, k2 = random.split(key)\n",
    "          glorot_stddev = 1. / np.sqrt((d_in + d_out) / 2.)\n",
    "          W = glorot_stddev * random.normal(k1, (d_in, d_out))\n",
    "          b = np.zeros(d_out)\n",
    "          return W, b\n",
    "      key, *keys = random.split(rng_key, len(layers))\n",
    "      params = list(map(init_layer, keys, layers[:-1], layers[1:]))\n",
    "      return params\n",
    "  def apply(params, inputs):\n",
    "      for W, b in params[:-1]:\n",
    "          outputs = np.dot(inputs, W) + b\n",
    "          inputs = activation(outputs)\n",
    "      W, b = params[-1]\n",
    "      outputs = np.dot(inputs, W) + b\n",
    "      return outputs\n",
    "  return init, apply\n",
    "\n",
    "# Define modified MLP\n",
    "def modified_MLP(layers, activation=relu):\n",
    "  def xavier_init(key, d_in, d_out):\n",
    "      glorot_stddev = 1. / np.sqrt((d_in + d_out) / 2.)\n",
    "      W = glorot_stddev * random.normal(key, (d_in, d_out))\n",
    "      b = np.zeros(d_out)\n",
    "      return W, b\n",
    "\n",
    "  def init(rng_key):\n",
    "      U1, b1 =  xavier_init(random.PRNGKey(12345), layers[0], layers[1])\n",
    "      U2, b2 =  xavier_init(random.PRNGKey(54321), layers[0], layers[1])\n",
    "      def init_layer(key, d_in, d_out):\n",
    "          k1, k2 = random.split(key)\n",
    "          W, b = xavier_init(k1, d_in, d_out)\n",
    "          return W, b\n",
    "      key, *keys = random.split(rng_key, len(layers))\n",
    "      params = list(map(init_layer, keys, layers[:-1], layers[1:]))\n",
    "      return (params, U1, b1, U2, b2) \n",
    "\n",
    "  def apply(params, inputs):\n",
    "      params, U1, b1, U2, b2 = params\n",
    "      U = activation(np.dot(inputs, U1) + b1)\n",
    "      V = activation(np.dot(inputs, U2) + b2)\n",
    "      for W, b in params[:-1]:\n",
    "          outputs = activation(np.dot(inputs, W) + b)\n",
    "          inputs = np.multiply(outputs, U) + np.multiply(1 - outputs, V) \n",
    "      W, b = params[-1]\n",
    "      outputs = np.dot(inputs, W) + b\n",
    "      return outputs\n",
    "  return init, apply\n"
   ],
   "execution_count": 11,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "yPdIBu2xPoi4"
   },
   "source": [
    "# Data generator\n",
    "class DataGenerator(data.Dataset):\n",
    "    def __init__(self, u, y, s, \n",
    "                 batch_size=64, rng_key=random.PRNGKey(1234)):\n",
    "        'Initialization'\n",
    "        self.u = u\n",
    "        self.y = y\n",
    "        self.s = s\n",
    "        \n",
    "        self.N = u.shape[0]\n",
    "        self.batch_size = batch_size\n",
    "        self.key = rng_key\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        'Generate one batch of data'\n",
    "        self.key, subkey = random.split(self.key)\n",
    "        inputs, outputs = self.__data_generation(subkey)\n",
    "        return inputs, outputs\n",
    "\n",
    "    @partial(jit, static_argnums=(0,))\n",
    "    def __data_generation(self, key):\n",
    "        'Generates data containing batch_size samples'\n",
    "        idx = random.choice(key, self.N, (self.batch_size,), replace=False)\n",
    "        s = self.s[idx,:]\n",
    "        y = self.y[idx,:]\n",
    "        u = self.u[idx,:]\n",
    "        # Construct batch\n",
    "        inputs = (u, y)\n",
    "        outputs = s\n",
    "        return inputs, outputs"
   ],
   "execution_count": 12,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "kbh_Vdc8VmZZ"
   },
   "source": [
    "# Define Physics-informed DeepONet model\n",
    "class PI_DeepONet:\n",
    "    def __init__(self, branch_layers, trunk_layers):    \n",
    "        # Network initialization and evaluation functions\n",
    "        self.branch_init, self.branch_apply = modified_MLP(branch_layers, activation=np.tanh)\n",
    "        self.trunk_init, self.trunk_apply = modified_MLP(trunk_layers, activation=np.tanh)\n",
    "\n",
    "        # Initialize\n",
    "        branch_params = self.branch_init(rng_key = random.PRNGKey(1234))\n",
    "        trunk_params = self.trunk_init(rng_key = random.PRNGKey(4321))\n",
    "        params = (branch_params, trunk_params)\n",
    "\n",
    "        # Use optimizers to set optimizer initialization and update functions\n",
    "        self.opt_init, \\\n",
    "        self.opt_update, \\\n",
    "        self.get_params = optimizers.adam(optimizers.exponential_decay(1e-3, \n",
    "                                                                      decay_steps=2000, \n",
    "                                                                      decay_rate=0.9))\n",
    "        self.opt_state = self.opt_init(params)\n",
    "\n",
    "        # Used to restore the trained model parameters\n",
    "        _, self.unravel_params = ravel_pytree(params)\n",
    "\n",
    "        # Logger\n",
    "        self.itercount = itertools.count()\n",
    "        self.loss_log = []\n",
    "        self.loss_ics_log = []\n",
    "        self.loss_bcs_log = []\n",
    "        self.loss_res_log = []\n",
    "\n",
    "    # Define DeepONet architecture\n",
    "    def operator_net(self, params, u, t, x):\n",
    "        branch_params, trunk_params = params\n",
    "        y = np.stack([t,x])\n",
    "        B = self.branch_apply(branch_params, u)\n",
    "        T = self.trunk_apply(trunk_params, y)\n",
    "        outputs = np.sum(B * T)\n",
    "        return   outputs\n",
    "    \n",
    "    # Define ds/dx\n",
    "    def s_x_net(self, params, u, t, x):\n",
    "         s_x = grad(self.operator_net, argnums=3)(params, u, t, x)\n",
    "         return s_x\n",
    "\n",
    "    # Define PDE residual        \n",
    "    def residual_net(self, params, u, t, x):\n",
    "        s = self.operator_net(params, u, t, x)\n",
    "        s_t = grad(self.operator_net, argnums=2)(params, u, t, x)\n",
    "        s_x = grad(self.operator_net, argnums=3)(params, u, t, x)\n",
    "        s_xx= grad(grad(self.operator_net, argnums=3), argnums=3)(params, u, t, x)\n",
    "\n",
    "        res = s_t + s * s_x - 0.01 * s_xx\n",
    "        return res\n",
    "\n",
    "    # Define initial loss\n",
    "    def loss_ics(self, params, batch):\n",
    "        # Fetch data\n",
    "        inputs, outputs = batch\n",
    "        u, y = inputs\n",
    "\n",
    "        # Compute forward pass\n",
    "        s_pred = vmap(self.operator_net, (None, 0, 0, 0))(params, u, y[:,0], y[:,1])\n",
    "\n",
    "        # Compute loss\n",
    "        loss = np.mean((outputs.flatten() - s_pred)**2)\n",
    "        return loss\n",
    "\n",
    "    # Define boundary loss\n",
    "    def loss_bcs(self, params, batch):\n",
    "        # Fetch data\n",
    "        inputs, outputs = batch\n",
    "        u, y = inputs\n",
    "\n",
    "        # Compute forward pass\n",
    "        s_bc1_pred = vmap(self.operator_net, (None, 0, 0, 0))(params, u, y[:,0], y[:,1])\n",
    "        s_bc2_pred = vmap(self.operator_net, (None, 0, 0, 0))(params, u, y[:,2], y[:,3])\n",
    "\n",
    "        s_x_bc1_pred = vmap(self.s_x_net, (None, 0, 0, 0))(params, u, y[:,0], y[:,1])\n",
    "        s_x_bc2_pred = vmap(self.s_x_net, (None, 0, 0, 0))(params, u, y[:,2], y[:,3])\n",
    "\n",
    "        # Compute loss\n",
    "        loss_s_bc = np.mean((s_bc1_pred - s_bc2_pred)**2)\n",
    "        loss_s_x_bc = np.mean((s_x_bc1_pred - s_x_bc2_pred)**2)\n",
    "\n",
    "        return loss_s_bc + loss_s_x_bc\n",
    "\n",
    "    # Define residual loss\n",
    "    def loss_res(self, params, batch):\n",
    "        # Fetch data\n",
    "        inputs, outputs = batch\n",
    "        u, y = inputs\n",
    "        # Compute forward pass\n",
    "        pred = vmap(self.residual_net, (None, 0, 0, 0))(params, u, y[:,0], y[:,1])\n",
    "\n",
    "        # Compute loss\n",
    "        loss = np.mean((outputs.flatten() - pred)**2)\n",
    "        return loss    \n",
    "\n",
    "    # Define total loss\n",
    "    def loss(self, params, ics_batch, bcs_batch, res_batch):\n",
    "        loss_ics = self.loss_ics(params, ics_batch)\n",
    "        loss_bcs = self.loss_bcs(params, bcs_batch)\n",
    "        loss_res = self.loss_res(params, res_batch)\n",
    "        loss =  20 * loss_ics + loss_bcs +  loss_res\n",
    "        return loss\n",
    "\n",
    "    # Define a compiled update step\n",
    "    @partial(jit, static_argnums=(0,))\n",
    "    def step(self, i, opt_state, ics_batch, bcs_batch, res_batch):\n",
    "        params = self.get_params(opt_state)\n",
    "        g = grad(self.loss)(params, ics_batch, bcs_batch, res_batch)\n",
    "        return self.opt_update(i, g, opt_state)\n",
    "\n",
    "    # Optimize parameters in a loop\n",
    "    def train(self, ics_dataset, bcs_dataset, res_dataset, nIter = 10000):\n",
    "        ics_data = iter(ics_dataset)\n",
    "        bcs_data = iter(bcs_dataset)\n",
    "        res_data = iter(res_dataset)\n",
    "\n",
    "        pbar = trange(nIter)\n",
    "        # Main training loop\n",
    "        for it in pbar:\n",
    "            # Fetch data\n",
    "            ics_batch= next(ics_data)\n",
    "            bcs_batch= next(bcs_data)\n",
    "            res_batch = next(res_data)\n",
    "\n",
    "            self.opt_state = self.step(next(self.itercount), self.opt_state, ics_batch, bcs_batch, res_batch)\n",
    "            \n",
    "            if it % 100 == 0:\n",
    "                params = self.get_params(self.opt_state)\n",
    "\n",
    "                # Compute losses\n",
    "                loss_value = self.loss(params, ics_batch, bcs_batch, res_batch)\n",
    "                loss_ics_value = self.loss_ics(params, ics_batch)\n",
    "                loss_bcs_value = self.loss_bcs(params, bcs_batch)\n",
    "                loss_res_value = self.loss_res(params, res_batch)\n",
    "\n",
    "                # Store losses\n",
    "                self.loss_log.append(loss_value)\n",
    "                self.loss_ics_log.append(loss_ics_value)\n",
    "                self.loss_bcs_log.append(loss_bcs_value)\n",
    "                self.loss_res_log.append(loss_res_value)\n",
    "\n",
    "                # Print losses\n",
    "                pbar.set_postfix({'Loss': loss_value, \n",
    "                                  'loss_ics' : loss_ics_value,\n",
    "                                  'loss_bcs' : loss_bcs_value, \n",
    "                                  'loss_physics': loss_res_value})\n",
    "           \n",
    "    # Evaluates predictions at test points  \n",
    "    @partial(jit, static_argnums=(0,))\n",
    "    def predict_s(self, params, U_star, Y_star):\n",
    "        s_pred = vmap(self.operator_net, (None, 0, 0, 0))(params, U_star, Y_star[:,0], Y_star[:,1])\n",
    "        return s_pred\n",
    "\n",
    "    @partial(jit, static_argnums=(0,))\n",
    "    def predict_res(self, params, U_star, Y_star):\n",
    "        r_pred = vmap(self.residual_net, (None, 0, 0, 0))(params, U_star, Y_star[:,0], Y_star[:,1])\n",
    "        return r_pred"
   ],
   "execution_count": 13,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "k6NL6NI7P9Jo"
   },
   "source": [
    "# Geneate ics training data corresponding to one input sample\n",
    "def generate_one_ics_training_data(key, u0, m=101, P=101):\n",
    "\n",
    "    t_0 = np.zeros((P,1))\n",
    "    x_0 = np.linspace(0, 1, P)[:, None]\n",
    "\n",
    "    y = np.hstack([t_0, x_0])\n",
    "    u = np.tile(u0, (P, 1))\n",
    "    s = u0\n",
    "\n",
    "    return u, y, s\n",
    "\n",
    "# Geneate bcs training data corresponding to one input sample\n",
    "def generate_one_bcs_training_data(key, u0, m=101, P=100):\n",
    "\n",
    "    t_bc = random.uniform(key, (P,1))\n",
    "    x_bc1 = np.zeros((P, 1))\n",
    "    x_bc2 = np.ones((P, 1))\n",
    "  \n",
    "    y1 = np.hstack([t_bc, x_bc1])  # shape = (P, 2)\n",
    "    y2 = np.hstack([t_bc, x_bc2])  # shape = (P, 2)\n",
    "\n",
    "    u = np.tile(u0, (P, 1))\n",
    "    y =  np.hstack([y1, y2])  # shape = (P, 4)\n",
    "    s = np.zeros((P, 1))\n",
    "\n",
    "    return u, y, s\n",
    "\n",
    "# Geneate res training data corresponding to one input sample\n",
    "def generate_one_res_training_data(key, u0, m=101, P=1000):\n",
    "\n",
    "    subkeys = random.split(key, 2)\n",
    "   \n",
    "    t_res = random.uniform(subkeys[0], (P,1))\n",
    "    x_res = random.uniform(subkeys[1], (P,1))\n",
    "\n",
    "    u = np.tile(u0, (P, 1))\n",
    "    y =  np.hstack([t_res, x_res])\n",
    "    s = np.zeros((P, 1))\n",
    "\n",
    "    return u, y, s\n",
    "\n",
    "# Geneate test data corresponding to one input sample\n",
    "def generate_one_test_data(idx,usol, m=101, P=101):\n",
    "\n",
    "    u = usol[idx]\n",
    "    u0 = u[0,:]\n",
    "\n",
    "    t = np.linspace(0, 1, P)\n",
    "    x = np.linspace(0, 1, P)\n",
    "    T, X = np.meshgrid(t, x)\n",
    "\n",
    "    s = u.T.flatten()\n",
    "    u = np.tile(u0, (P**2, 1))\n",
    "    y = np.hstack([T.flatten()[:,None], X.flatten()[:,None]])\n",
    "\n",
    "    return u, y, s \n",
    "\n",
    "# Geneate training data corresponding to N input sample\n",
    "def compute_error(idx, usol, m, P):\n",
    "    u_test, y_test, s_test = generate_one_test_data(idx, usol, m, P)\n",
    "\n",
    "    u_test = u_test.reshape(P**2,-1)  \n",
    "    y_test = y_test.reshape(P**2,-1)\n",
    "    s_test = s_test.reshape(P**2,-1)\n",
    "\n",
    "    s_pred = model.predict_s(params, u_test, y_test)[:,None]\n",
    "    error = np.linalg.norm(s_test - s_pred) / np.linalg.norm(s_test) \n",
    "\n",
    "    return error  "
   ],
   "execution_count": 14,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "POD_ip6zwvWL"
   },
   "source": [
    "# Prepare the training data\n",
    "\n",
    "# Load data\n",
    "path = 'Burger.mat'  # Please use the matlab script to generate data\n",
    "\n",
    "data = scipy.io.loadmat(path)\n",
    "usol = np.array( data['output'])\n",
    "\n",
    "N = usol.shape[0]  # number of total input samples\n",
    "N_train =1000      # number of input samples used for training\n",
    "N_test = N - N_train  # number of input samples used for test\n",
    "m = 101            # number of sensors for input samples\n",
    "P_ics_train = 101   # number of locations for evulating the initial condition\n",
    "P_bcs_train = 100    # number of locations for evulating the boundary condition\n",
    "P_res_train = 2500   # number of locations for evulating the PDE residual\n",
    "P_test = 101        # resolution of uniform grid for the test data\n",
    "\n",
    "u0_train = usol[:N_train,0,:]   # input samples\n",
    "# usol_train = usol[:N_train,:,:]\n",
    "\n",
    "key = random.PRNGKey(0) # use different key for generating test data \n",
    "keys = random.split(key, N_train)\n",
    "\n",
    "# Generate training data for inital condition\n",
    "u_ics_train, y_ics_train, s_ics_train = vmap(generate_one_ics_training_data, in_axes=(0, 0, None, None))(keys, u0_train, m, P_ics_train)\n",
    "\n",
    "u_ics_train = u_ics_train.reshape(N_train * P_ics_train,-1)  \n",
    "y_ics_train = y_ics_train.reshape(N_train * P_ics_train,-1)\n",
    "s_ics_train = s_ics_train.reshape(N_train * P_ics_train,-1)\n",
    "\n",
    "# Generate training data for boundary condition\n",
    "u_bcs_train, y_bcs_train, s_bcs_train = vmap(generate_one_bcs_training_data, in_axes=(0, 0, None, None))(keys, u0_train, m, P_bcs_train)\n",
    "\n",
    "u_bcs_train = u_bcs_train.reshape(N_train * P_bcs_train,-1)  \n",
    "y_bcs_train = y_bcs_train.reshape(N_train * P_bcs_train,-1)\n",
    "s_bcs_train = s_bcs_train.reshape(N_train * P_bcs_train,-1)\n",
    "\n",
    "# Generate training data for PDE residual\n",
    "u_res_train, y_res_train, s_res_train = vmap(generate_one_res_training_data, in_axes=(0, 0, None, None))(keys, u0_train, m, P_res_train)\n",
    "\n",
    "u_res_train = u_res_train.reshape(N_train * P_res_train,-1)  \n",
    "y_res_train = y_res_train.reshape(N_train * P_res_train,-1)\n",
    "s_res_train = s_res_train.reshape(N_train * P_res_train,-1)"
   ],
   "execution_count": 15,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "3e0d9ay6he_Q"
   },
   "source": [
    "# Initialize model\n",
    "branch_layers = [m, 100, 100, 100, 100, 100, 100, 100]\n",
    "trunk_layers =  [2, 100, 100, 100, 100, 100, 100, 100]\n",
    "model = PI_DeepONet(branch_layers, trunk_layers)"
   ],
   "execution_count": 16,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "BmduhGwcHHXs"
   },
   "source": [
    "# Create data set\n",
    "batch_size = 50000\n",
    "ics_dataset = DataGenerator(u_ics_train, y_ics_train, s_ics_train, batch_size)\n",
    "bcs_dataset = DataGenerator(u_bcs_train, y_bcs_train, s_bcs_train, batch_size)\n",
    "res_dataset = DataGenerator(u_res_train, y_res_train, s_res_train, batch_size)"
   ],
   "execution_count": 17,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "gW8Ej5Jvhf0r"
   },
   "source": [
    "# Train\n",
    "# Note: may meet OOM issue if use Colab. Please train this model on the server.  \n",
    "# model.train(ics_dataset, bcs_dataset, res_dataset, nIter=200000)"
   ],
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "hFf9NGzBiDS5"
   },
   "source": [
    "# Restore the trained model\n",
    "# params = model.get_params(model.opt_state)\n",
    "\n",
    "lam = 20\n",
    "params = model.unravel_params(np.load('modified_MLP_lam_{}_params.npy'.format(lam)))"
   ],
   "execution_count": 20,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "05zrmpicNOHR",
    "outputId": "2f01bece-8b3c-481b-8e24-e49bad8efbbc"
   },
   "source": [
    "# Compute relative l2 error over test data\n",
    "idx = random.randint(key=random.PRNGKey(12345), shape=(400,), minval=N_train, maxval=2000)\n",
    "k= 1500\n",
    "N_test = 100\n",
    "idx = np.arange(k, k + N_test)\n",
    "\n",
    "errors = vmap(compute_error, in_axes=(0, None, None, None))(idx, usol, m, P_test)\n",
    "mean_error = errors.mean()\n",
    "\n",
    "print('Mean relative L2 error of s: {:.2e}'.format(mean_error))"
   ],
   "execution_count": 21,
   "outputs": [
    {
     "output_type": "stream",
     "text": [
      "Mean relative L2 error of s: 1.42e-02\n"
     ],
     "name": "stdout"
    }
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "uhMrQopGN__b"
   },
   "source": [
    "# Plot for loss function\n",
    "plt.figure(figsize = (6,5))\n",
    "# plt.plot(model.loss_log, lw=2)\n",
    "plt.plot(model.loss_ics_log, lw=2, label='ics')\n",
    "plt.plot(model.loss_bcs_log, lw=2, label='bcs')\n",
    "plt.plot(model.loss_res_log, lw=2, label='res')\n",
    "\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Loss')\n",
    "plt.yscale('log')\n",
    "plt.legend()\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ],
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "NicghBbsmLUH",
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 386
    },
    "outputId": "1104c0ac-9b35-4146-aa91-ff610a7598fc"
   },
   "source": [
    "# Plot for one generated data\n",
    "k = 1833 # index\n",
    "u = usol[k,:, :]\n",
    "u0 = usol[k,0,:]\n",
    "\n",
    "P_test = 101\n",
    "\n",
    "t = np.linspace(0, 1, P_test)\n",
    "x = np.linspace(0, 1, P_test)\n",
    "T, X = np.meshgrid(t, x)\n",
    "\n",
    "u_test = np.tile(u0, (P_test**2, 1))\n",
    "y_test = np.hstack([T.flatten()[:,None], X.flatten()[:,None]])\n",
    "s_test = u.flatten()[:,None]\n",
    "\n",
    "s_pred = model.predict_s(params, u_test, y_test)[:,None]\n",
    "S_pred = griddata(y_test, s_pred.flatten(), (T, X), method='cubic')\n",
    "\n",
    "\n",
    "error_s = np.linalg.norm(u - S_pred.T, 2) / np.linalg.norm(u, 2) \n",
    "\n",
    "print(\"error_s: {:.3e}\".format(error_s))\n",
    "\n",
    "fig = plt.figure(figsize=(18,5))\n",
    "plt.subplot(1,3,1)\n",
    "plt.pcolor(T, X, u, cmap='jet')\n",
    "plt.xlabel('$x$')\n",
    "plt.ylabel('$t$')\n",
    "plt.title('Exact $s(x,t)$')\n",
    "plt.colorbar()\n",
    "plt.tight_layout()\n",
    "\n",
    "plt.subplot(1,3,2)\n",
    "plt.pcolor(T, X, S_pred.T, cmap='jet')\n",
    "plt.xlabel('$x$')\n",
    "plt.ylabel('$t$')\n",
    "plt.title('Predict $s(x,t)$')\n",
    "plt.colorbar()\n",
    "plt.tight_layout()\n",
    "\n",
    "plt.subplot(1,3,3)\n",
    "plt.pcolor(T, X, np.abs(S_pred.T - u), cmap='jet')\n",
    "plt.xlabel('$x$')\n",
    "plt.ylabel('$t$')\n",
    "plt.title('Absolute error')\n",
    "plt.colorbar()\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ],
   "execution_count": 24,
   "outputs": [
    {
     "output_type": "stream",
     "text": [
      "error_s: 3.307e-02\n"
     ],
     "name": "stdout"
    },
    {
     "output_type": "display_data",
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x360 with 6 Axes>"
      ]
     },
     "metadata": {
      "tags": [],
      "needs_background": "light"
     }
    }
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "zkvd57ZuO6z1"
   },
   "source": [],
   "execution_count": null,
   "outputs": []
  }
 ]
}
